home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / share / bison / c.m4 next >
Encoding:
Text File  |  2006-04-25  |  11.5 KB  |  441 lines
  1. m4_divert(-1)                                               -*- Autoconf -*-
  2.  
  3. # C M4 Macros for Bison.
  4. # Copyright (C) 2002, 2004, 2005 Free Software Foundation, Inc.
  5.  
  6. # This program is free software; you can redistribute it and/or modify
  7. # it under the terms of the GNU General Public License as published by
  8. # the Free Software Foundation; either version 2 of the License, or
  9. # (at your option) any later version.
  10.  
  11. # This program is distributed in the hope that it will be useful,
  12. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. # GNU General Public License for more details.
  15.  
  16. # You should have received a copy of the GNU General Public License
  17. # along with this program; if not, write to the Free Software
  18. # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19. # 02110-1301  USA
  20.  
  21.  
  22. ## ---------------- ##
  23. ## Identification.  ##
  24. ## ---------------- ##
  25.  
  26. # b4_copyright(TITLE, YEARS)
  27. # --------------------------
  28. m4_define([b4_copyright],
  29. [/* A Bison parser, made by GNU Bison b4_version.  */
  30.  
  31. /* $1,
  32.    Copyright (C) $2 Free Software Foundation, Inc.
  33.  
  34.    This program is free software; you can redistribute it and/or modify
  35.    it under the terms of the GNU General Public License as published by
  36.    the Free Software Foundation; either version 2, or (at your option)
  37.    any later version.
  38.  
  39.    This program is distributed in the hope that it will be useful,
  40.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  41.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  42.    GNU General Public License for more details.
  43.  
  44.    You should have received a copy of the GNU General Public License
  45.    along with this program; if not, write to the Free Software
  46.    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  47.    Boston, MA 02110-1301, USA.  */])
  48.  
  49.  
  50. # b4_identification
  51. # -----------------
  52. m4_define([b4_identification],
  53. [/* Identify Bison output.  */
  54. [#]define YYBISON 1
  55.  
  56. /* Bison version.  */
  57. [#]define YYBISON_VERSION "b4_version"
  58.  
  59. /* Skeleton name.  */
  60. [#]define YYSKELETON_NAME b4_skeleton
  61.  
  62. /* Pure parsers.  */
  63. [#]define YYPURE b4_pure
  64.  
  65. /* Using locations.  */
  66. [#]define YYLSP_NEEDED b4_locations_flag
  67. ])
  68.  
  69.  
  70.  
  71. ## ---------------- ##
  72. ## Default values.  ##
  73. ## ---------------- ##
  74.  
  75. m4_define_default([b4_epilogue], [])
  76.  
  77.  
  78.  
  79. ## ------------------------ ##
  80. ## Pure/impure interfaces.  ##
  81. ## ------------------------ ##
  82.  
  83.  
  84. # b4_user_args
  85. # ------------
  86. m4_define([b4_user_args],
  87. [m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])])
  88.  
  89.  
  90. # b4_parse_param
  91. # --------------
  92. # If defined, b4_parse_param arrives double quoted, but below we prefer
  93. # it to be single quoted.
  94. m4_define_default([b4_parse_param])
  95. m4_define([b4_parse_param],
  96. b4_parse_param))
  97.  
  98.  
  99.  
  100. ## ------------ ##
  101. ## Data Types.  ##
  102. ## ------------ ##
  103.  
  104.  
  105. # b4_ints_in(INT1, INT2, LOW, HIGH)
  106. # ---------------------------------
  107. # Return 1 iff both INT1 and INT2 are in [LOW, HIGH], 0 otherwise.
  108. m4_define([b4_ints_in],
  109. [m4_eval([$3 <= $1 && $1 <= $4 && $3 <= $2 && $2 <= $4])])
  110.  
  111.  
  112. # b4_int_type(MIN, MAX)
  113. # ---------------------
  114. # Return the smallest int type able to handle numbers ranging from
  115. # MIN to MAX (included).
  116. m4_define([b4_int_type],
  117. [m4_if(b4_ints_in($@,      [0],   [255]), [1], [unsigned char],
  118.        b4_ints_in($@,   [-128],   [127]), [1], [signed char],
  119.  
  120.        b4_ints_in($@,      [0], [65535]), [1], [unsigned short int],
  121.        b4_ints_in($@, [-32768], [32767]), [1], [short int],
  122.  
  123.        m4_eval([0 <= $1]),                [1], [unsigned int],
  124.  
  125.                                            [int])])
  126.  
  127.  
  128. # b4_int_type_for(NAME)
  129. # ---------------------
  130. # Return the smallest int type able to handle numbers ranging from
  131. # `NAME_min' to `NAME_max' (included).
  132. m4_define([b4_int_type_for],
  133. [b4_int_type($1_min, $1_max)])
  134.  
  135.  
  136. ## ------------------ ##
  137. ## Decoding options.  ##
  138. ## ------------------ ##
  139.  
  140.  
  141. # b4_location_if(IF-TRUE, IF-FALSE)
  142. # ---------------------------------
  143. # Expand IF-TRUE, if locations are used, IF-FALSE otherwise.
  144. m4_define([b4_location_if],
  145. [m4_if(b4_locations_flag, [1],
  146.        [$1],
  147.        [$2])])
  148.  
  149.  
  150. # b4_pure_if(IF-TRUE, IF-FALSE)
  151. # -----------------------------
  152. # Expand IF-TRUE, if %pure-parser, IF-FALSE otherwise.
  153. m4_define([b4_pure_if],
  154. [m4_if(b4_pure, [1],
  155.        [$1],
  156.        [$2])])
  157.  
  158.  
  159.  
  160. ## ------------------------- ##
  161. ## Assigning token numbers.  ##
  162. ## ------------------------- ##
  163.  
  164. # b4_token_define(TOKEN-NAME, TOKEN-NUMBER)
  165. # -----------------------------------------
  166. # Output the definition of this token as #define.
  167. m4_define([b4_token_define],
  168. [#define $1 $2
  169. ])
  170.  
  171.  
  172. # b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
  173. # -------------------------------------------------------
  174. # Output the definition of the tokens (if there are) as #defines.
  175. m4_define([b4_token_defines],
  176. [m4_if([$@], [[]], [],
  177. [/* Tokens.  */
  178. m4_map([b4_token_define], [$@])])
  179. ])
  180.  
  181.  
  182. # b4_token_enum(TOKEN-NAME, TOKEN-NUMBER)
  183. # ---------------------------------------
  184. # Output the definition of this token as an enum.
  185. m4_define([b4_token_enum],
  186. [$1 = $2])
  187.  
  188.  
  189. # b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
  190. # -----------------------------------------------------
  191. # Output the definition of the tokens (if there are) as enums.
  192. m4_define([b4_token_enums],
  193. [m4_if([$@], [[]], [],
  194. [/* Tokens.  */
  195. #ifndef YYTOKENTYPE
  196. # define YYTOKENTYPE
  197.    /* Put the tokens into the symbol table, so that GDB and other debuggers
  198.       know about them.  */
  199.    enum yytokentype {
  200. m4_map_sep([     b4_token_enum], [,
  201. ],
  202.            [$@])
  203.    };
  204. #endif
  205. ])])
  206.  
  207.  
  208. # b4_token_enums_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
  209. # -------------------------------------------------------------
  210. # Output the definition of the tokens (if there are) as enums and #defines.
  211. m4_define([b4_token_enums_defines],
  212. [b4_token_enums($@)b4_token_defines($@)
  213. ])
  214.  
  215.  
  216.  
  217. ## --------------------------------------------- ##
  218. ## Defining C functions in both K&R and ANSI-C.  ##
  219. ## --------------------------------------------- ##
  220.  
  221.  
  222. # b4_c_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
  223. # ----------------------------------------------------------
  224. # Declare the function NAME.
  225. m4_define([b4_c_function_def],
  226. [#if defined (__STDC__) || defined (__cplusplus)
  227. b4_c_ansi_function_def($@)
  228. #else
  229. $2
  230. $1 (b4_c_knr_formal_names(m4_shiftn(2, $@)))
  231. b4_c_knr_formal_decls(m4_shiftn(2, $@))
  232. #endif[]dnl
  233. ])
  234.  
  235.  
  236. # b4_c_ansi_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
  237. # ---------------------------------------------------------------
  238. # Declare the function NAME in ANSI.
  239. m4_define([b4_c_ansi_function_def],
  240. [$2
  241. $1 (b4_c_ansi_formals(m4_shiftn(2, $@)))[]dnl
  242. ])
  243.  
  244.  
  245. # b4_c_ansi_formals([DECL1, NAME1], ...)
  246. # --------------------------------------
  247. # Output the arguments ANSI-C definition.
  248. m4_define([b4_c_ansi_formals],
  249. [m4_case([$@],
  250.          [],   [void],
  251.          [[]], [void],
  252.                [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])])
  253.  
  254. m4_define([b4_c_ansi_formal],
  255. [$1])
  256.  
  257.  
  258. # b4_c_knr_formal_names([DECL1, NAME1], ...)
  259. # ------------------------------------------
  260. # Output the argument names.
  261. m4_define([b4_c_knr_formal_names],
  262. [m4_map_sep([b4_c_knr_formal_name], [, ], [$@])])
  263.  
  264. m4_define([b4_c_knr_formal_name],
  265. [$2])
  266.  
  267.  
  268. # b4_c_knr_formal_decls([DECL1, NAME1], ...)
  269. # ------------------------------------------
  270. # Output the K&R argument declarations.
  271. m4_define([b4_c_knr_formal_decls],
  272. [m4_map_sep([b4_c_knr_formal_decl],
  273.             [
  274. ],
  275.             [$@])])
  276.  
  277. m4_define([b4_c_knr_formal_decl],
  278. [    $1;])
  279.  
  280.  
  281.  
  282. ## ------------------------------------------------------------ ##
  283. ## Declaring (prototyping) C functions in both K&R and ANSI-C.  ##
  284. ## ------------------------------------------------------------ ##
  285.  
  286.  
  287. # b4_c_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
  288. # -----------------------------------------------------------
  289. # Declare the function NAME.
  290. m4_define([b4_c_function_decl],
  291. [#if defined (__STDC__) || defined (__cplusplus)
  292. b4_c_ansi_function_decl($@)
  293. #else
  294. $2 $1 ();
  295. #endif[]dnl
  296. ])
  297.  
  298.  
  299. # b4_c_ansi_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
  300. # ----------------------------------------------------------------
  301. # Declare the function NAME.
  302. m4_define([b4_c_ansi_function_decl],
  303. [$2 $1 (b4_c_ansi_formals(m4_shiftn(2, $@)));[]dnl
  304. ])
  305.  
  306.  
  307.  
  308.  
  309. ## --------------------- ##
  310. ## Calling C functions.  ##
  311. ## --------------------- ##
  312.  
  313.  
  314. # b4_c_function_call(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
  315. # -----------------------------------------------------------
  316. # Call the function NAME with arguments NAME1, NAME2 etc.
  317. m4_define([b4_c_function_call],
  318. [$1 (b4_c_args(m4_shiftn(2, $@)))[]dnl
  319. ])
  320.  
  321.  
  322. # b4_c_args([DECL1, NAME1], ...)
  323. # ------------------------------
  324. # Output the arguments NAME1, NAME2...
  325. m4_define([b4_c_args],
  326. [m4_map_sep([b4_c_arg], [, ], [$@])])
  327.  
  328. m4_define([b4_c_arg],
  329. [$2])
  330.  
  331.  
  332. ## ----------- ##
  333. ## Synclines.  ##
  334. ## ----------- ##
  335.  
  336.  
  337. # b4_syncline(LINE, FILE)
  338. # -----------------------
  339. m4_define([b4_syncline],
  340. [m4_if(b4_synclines_flag, 1,
  341.        [[#]line $1 $2])])
  342.  
  343.  
  344. # b4_symbol_actions(FILENAME, LINENO,
  345. #                   SYMBOL-TAG, SYMBOL-NUM,
  346. #                   SYMBOL-ACTION, SYMBOL-TYPENAME)
  347. # -------------------------------------------------
  348. m4_define([b4_symbol_actions],
  349. [m4_pushdef([b4_dollar_dollar],
  350.    [m4_ifval([$6], [(yyvaluep->$6)], [(*yyvaluep)])])dnl
  351. m4_pushdef([b4_at_dollar], [(*yylocationp)])dnl
  352.       case $4: /* $3 */
  353. b4_syncline([$2], [$1])
  354.         $5;
  355. b4_syncline([@oline@], [@ofile@])
  356.         break;
  357. m4_popdef([b4_at_dollar])dnl
  358. m4_popdef([b4_dollar_dollar])dnl
  359. ])
  360.  
  361.  
  362. # b4_yydestruct_generate(FUNCTION-DECLARATOR)
  363. # -------------------------------------------
  364. # Generate the "yydestruct" function, which declaration is issued using
  365. # FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C
  366. # or "b4_c_function_def" for K&R.
  367. m4_define_default([b4_yydestruct_generate],
  368. [[/*-----------------------------------------------.
  369. | Release the memory associated to this symbol.  |
  370. `-----------------------------------------------*/
  371.  
  372. ]$1([yydestruct],
  373.     [static void],
  374.     [[const char *yymsg],    [yymsg]],
  375.     [[int yytype],           [yytype]],
  376.     [[YYSTYPE *yyvaluep],    [yyvaluep]]b4_location_if([,
  377.     [[YYLTYPE *yylocationp], [yylocationp]]]))[
  378. {
  379.   /* Pacify ``unused variable'' warnings.  */
  380.   (void) yyvaluep;
  381. ]b4_location_if([  (void) yylocationp;
  382. ])[
  383.   if (!yymsg)
  384.     yymsg = "Deleting";
  385.   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
  386.  
  387.   switch (yytype)
  388.     {
  389. ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
  390.       default:
  391.         break;
  392.     }
  393. }]dnl
  394. ])
  395.  
  396.  
  397. # b4_yysymprint_generate(FUNCTION-DECLARATOR)
  398. # -------------------------------------------
  399. # Generate the "yysymprint" function, which declaration is issued using
  400. # FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C
  401. # or "b4_c_function_def" for K&R.
  402. m4_define_default([b4_yysymprint_generate],
  403. [[/*--------------------------------.
  404. | Print this symbol on YYOUTPUT.  |
  405. `--------------------------------*/
  406.  
  407. ]$1([yysymprint],
  408.     [static void],
  409.     [[FILE *yyoutput],       [yyoutput]],
  410.     [[int yytype],           [yytype]],
  411.     [[YYSTYPE *yyvaluep],    [yyvaluep]]b4_location_if([,
  412.     [[YYLTYPE *yylocationp], [yylocationp]]]))
  413. {
  414.   /* Pacify ``unused variable'' warnings.  */
  415.   (void) yyvaluep;
  416. b4_location_if([  (void) yylocationp;
  417. ])dnl
  418. [
  419.   if (yytype < YYNTOKENS)
  420.     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
  421.   else
  422.     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
  423.  
  424. ]b4_location_if([  YY_LOCATION_PRINT (yyoutput, *yylocationp);
  425.   YYFPRINTF (yyoutput, ": ");
  426. ])dnl
  427. [
  428. # ifdef YYPRINT
  429.   if (yytype < YYNTOKENS)
  430.     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
  431. # endif
  432.   switch (yytype)
  433.     {
  434. ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
  435. [      default:
  436.         break;
  437.     }
  438.   YYFPRINTF (yyoutput, ")");
  439. }
  440. ]])
  441.